.TITLE	EXDBT
	.IDENT	/08.02/
;
; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED
; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
; D. N. CUTLER 7-DEC-74
;
; MODIFIED FOR RSX-11M-PLUS VERSION 2 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS V2.1 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 3.0 BY:
;
;	J. C. FRANZINI
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.0 BY:
;
;	B. S. MCCARTHY
;	K. L. NOEL
; 
; MODIFIED FOR RSX-11M-PLUS VERSION 4.1 BY:
;
;	K. L. NOEL	11-JAN-88	V08.02
;
;		KLN076 -- FIX DOUBLE "P" PROBLEM FOR CPR
;
;
; THIS IS A VERSION OF ODT THAT MAY BE USED TO DEBUG RSX-11M EXECUTIVE
; MODULES. IT IS AN OUTGROWTH OF THE STANDARD RSX-11 ODT WHICH WAS PRO-
; DUCED BY M. SMITH , H. LEV ET. AL.
;
; MACRO LIBRARY CALLS
;

	.MCALL	HWDDF$
	.MCALL	CPRDF$
	HWDDF$			;DEFINE HARDWARE REGISTERS
	CPRDF$			;DEFINE CPR SPECIFIC SYMBOLS

;
; EQUATED SYMBOLS
;

BPT=3				;BREAKPOINT INSTRUCTION CODE
BKP=16				;NUMBER OF BREAKPOINTS -1 X 2
LPB=177516			;LINE PRINTER BUFFER REGISTER
LPS=177514			;LINE PRINTER STATUS REGISTER
RLR=16				;NUMBER OF RELOCATION REGISTERS -1 X 2
TBT=20				;T-BIT MASK FOR PROCESSOR STATUS WORD
TKB=177562			;CONSOLE TERMINAL INPUT BUFFER REGISTER
TKS=177560			;CONSOLE TERMINAL INPUT STATUS REGISTER
TPB=177566			;CONSOLE TERMINAL OUTPUT BUFFER REGISTER
TPS=177564			;CONSOLE TERMINAL OUTPUT STATUS REGISTER
TPR0=0
TPR1=2
TPR2=4
TPR3=6

;
; LOCAL MACROS
;
; DECODE NEXT COMMAND
;

	.MACRO	DECODE
	IOT
	.ENDM

;
; ERROR
;

	.MACRO	ERROR
	EMT	0
	.ENDM

;
; TEST MODE FOR EXEC OR USER
;

	.MACRO	TESTM ADDR
	JSR	R5,TESTM
	.WORD	ADDR
	.ENDM

;
; TYPE OUT CHARACTER(S)
;
;	TYPE OUT IS EFFECTED WITH A TRAP INSTRUCTION WITH THE BOTTOM
;	BYTE ENCODED AS FOLLOWS:
;
;		300 = OUTPUT BOTH BYTES IN R0.
;		200 = OUTPUT LOW BYTE IN R0.
;		340 = OUTPUT A <CR><LF> SEQUENCE.
;		240 = OUTPUT A <CR> SEQUENCE.
;
;		ALL OTHER COMBINATIONS ARE TREATED AS THE ACTUAL BYTE
;		TO OUTPUT.

	.MACRO	TYPE ARG
	.IF IDN	<ARG>,<R0>
	TRAP	200
	.IFF
	.IF IDN	<ARG>,<R0+R0>
	TRAP	300
	.IFF
	.IF IDN	<ARG>,<CRLF>
	TRAP	340
	.IFF
	.IF IDN	<ARG>,<CR>
	TRAP	240
	.IFF
	TRAP	ARG&177
	.ENDC
	.ENDC
	.ENDC
	.ENDC
	.ENDM

	.PAGE
	.SBTTL	MULTIPROCESSOR LOADABLE XDT NODE

;
; THIS IS A COPY OF THE PROTOTYPE NODE IN XDTINI. IT MUST BE KEPT IN SYNC
; WITH THAT COPY.
;

	.IF DF L$$XDT&M$$PRO

$XDTND::			; PROTOTYPE CODE START ADDRESS
.PROTO
.AISA5:	.WORD	0		; ADDRESS OF APR5 (PSEUDO D)
.XDTA5:	.BLKW	1		; XDT APR5 CONTENTS
.KISA5:	.BLKW	1		; SAVED APR5 CONTENTS DURING XDT
.KINA5:	.BLKW	1		; SAVED I-SPACE APR5 CONTENTS DURING XDT
.VECTR:	.WORD	V$$CTR+4	; HIGHEST VECTOR ADDRESS (DEFAULTED
				; TO ASSEMBLY VALUE)

.RTN:	MOV	.KINA5,@#KINAR5 ; RESTORE I SPACE APR5
	MOV	.KISA5,@.AISA5  ; RESTORE D SPACE APR5 IF NECESSARY
.RTNI:	RTI			; EXIT TO EXEC (MAY BE CHANGED TO RTI)

.CRSH:	MOV	.KINA5,@#KINAR5 ; RESTORE I SPACE APR5
	MOV	.KISA5,@.AISA5  ; RESTORE D SPACE APR5 IF NECESSARY
	JMP	@#0		; JUMP TO CRASH
.CRADD = .-2			; ADDRESS OF CRASH ADDRESS

.ODDA:	CMP	SP,.VECTR	; STACK OVERFLOW ?
	BLO	.SOVFL		; IF LO YES
	JSR	R5,.COMMN	; ODD ADDRESS OR OTHER TRAP FOUR
	.WORD	0
.SGMT:	JSR	R5,.COMMN	; SEGMENT FAULT
	.WORD	2
.BPTI:	JSR	R5,.COMMN	; BREAKPOINTS,T-BIT TRAPS
	.WORD	4
.IOTX:	JSR	R5,.COMMN	; IOT INSTRUCTION TRAPS
	.WORD	6
.ILLI:	JSR	R5,.COMMN	; ILLEGAL INSTRUCTION TRAPS (->10)
	.WORD	10
.NEMT:	JSR	R5,.COMMN	; EMT TRAPS
	.WORD	12
	JMP	@#0		; ALWAYS ALLOW EXEC TO HANDLE TRAPS
.TRADD = .-2			; ADDRESS OF CRASH ADDRESS
	.WORD	0
.FPPE:	JSR	R5,.COMMN	; 11/40 FLOATING POINT EXCEPTIONS
	.WORD	16

.COMMN:	MOV	(R5),R5		; GET SST VECTOR OFFSET
	MOV	@#KINAR5,.KINA5	; SAVE I SPACE APR5
	MOV	@.AISA5,.KISA5	; SAVE D SPACE APR5 IF NECESSARY
	MOV	.XDTA5,@#KINAR5	; MAP INTO XDT IN I SPACE
	MOV	.XDTA5,@.AISA5	; MAP INTO XDT IN D SPACE IF NECESSARY
	ADD	#SSTVC1,R5	; POINT TO EXEC SST ADDR
	MOV	(R5),R5		; AND GET IT
	RTS	R5		; AND OFF TO XDT !
.SOVFL:	MOV	@#KINAR5,.KINA5	; SAVE I SPACE APR5
	MOV	@.AISA5,.KISA5	; SAVE D SPACE APR5 IF NECESSARY
	MOV	.XDTA5,@#KINAR5	; MAP INTO XDT IN I SPACE
	MOV	.XDTA5,@.AISA5	; MAP INTO XDT IN D SPACE IF NECESSARY
	JMP	@#SOVFL		; JUMP TO STACK OVERFLOW ENTRY POINT

.PLENG = . - .PROTO		; LENGTH OF DSR BLOCK

	.ENDC	; DF L$$XDT&M$$PRO
	.PAGE

	.IF DF	X$$DBT

	.SBTTL	LOCAL DATA
;
; LOCAL DATA
;
; CONTEXT VARIABLES
; THE ORDER OF THESE ITEMS IS INTENTIONAL, SEE REGISTER MAPPING SCHEME
;

INTBEG	=.	;STARTING ADDRESS OF INTERNAL REGISTERS

UR0:	0			;USER R0			$0
	0			;     R1			$1
	0			;     R2			$2
	0			;     R3			$3
	0			;     R4			$4
	0			;     R5			$5
USP:	0			;USER SP			$6
UPC:	$INITL			;USER PC			$7
UST:	PR7			;USER PS			$S
ARG:	0			;ARGUMENT REGISTER		$A
LOW:	0			;LOW LIMIT			$L
HI:	0			;HIGH LIMIT			$H
CNST:	$XDT			;CONSTANT REGISTER		$C
QUAN:	0			;QUANTITY REGISTER		$Q
FORM:	0			;FORMAT REGISTER		$F

;
; INTERNAL TABLES
;

INTINX	=.		;STARTING ADDRESS OF INTERNAL TABLES

;
; BREAKPOINT CONTROL LISTS, AND EXTRA SLOT FOR SINGLE STEP
;

ADR1:		;ADDRESS OF THE BREAKPOINT	($0B-$7B)
	.WORD	TRTC,TRTC,TRTC,TRTC,TRTC,TRTC,TRTC,TRTC,TRTC

CT:		;PROCEED COUNT	($0G-$7G)
	.WORD	1,1,1,1,1,1,1,1,1

UIN:		;USER INSTRUCTION SAVE LOCATION	($0I-$7I)
	.WORD	BPT,BPT,BPT,BPT,BPT,BPT,BPT,BPT,BPT

;
; RELOCATION REGISTERS
;

RELT:		;RELOCATION TABLES	($0R-$7R)
	.WORD	-1,-1,-1,-1,-1,-1,-1,-1

INTEND=.-2			;END OF INTERNAL REGISTERS AND TABLES

;
; EXEC SST TRAP VECTOR ADDRESSES
;
; THIS TABLE IS READ/WRITE AND THERE IS ONE SUCH TABLE PER PROCESSOR
;

SSTVEC:	 +	ODDA		;0-ODD ADDRESS, OR HALT, VECTOR @4
	 +	SGMT		;1-SEGMENT FAULT
	 +	BPTI		;2-T-BIT OR BPT
	 +	IOTX		;3-IOT
	 +	ILLI		;4-RESERVED OR ILLEGAL INSTRUCTION
	 +	NEMT		;5-EMT
	 +	$TRTRP		;6-TRAP (EXECUTIVE ALWAYS HANDLES TRAPS)

;
; WORDS AND ORDERED BYTES, ITEMS MUST BE KEPT FROM COMMAND TO COMMAND
;

CAD:	.WORD	0		;ADDRESS OF CURRENTLY OPEN REGISTER
DOT:	.WORD	0		;ADDRESS OF LAST EXPLICITLY OPENED CELL
BW:	.WORD	0		;LAST OPEN MODE 1=BYTE, 2=WORD
OPN:	.WORD	0		;LOCATION OPEN FLAG 0=NOT OPEN, NON-ZERO=OPEN
D.ARGS:	.WORD	0		;SEMI COLON PUSH WORD

;
; THE FOLLOWING ITEMS NEED NOT BE KEPT FROM COMMAND TO COMMAND
; THEIR ORDER IS INTENTIONAL SO KNOW THY MAKER!
;

OP:	.BYTE	0		;CURRENT ARITHMETIC OPERATOR
SMFD:	.BYTE	0		;SEMI-COLON COUNTER
EXP:	.WORD	0		;EXPRESSION BUCKET
OUTB:	.WORD	TPB		;CONSOLE PRINTER BUFFER ADDRESS
OUTS:	.WORD	TPS		;CONSOLE PRINTER STATUS REGISTER
PPC:	.BLKW	1		;SAVED PC LAST BREAKPOINT


	.IF DF	M$$PRO

STENB:	.BLKW	1		;USED TO REENABLE SANITY TIMER IF IT
				;WAS ENABLED WHEN XDT WAS ENTERED

	.ENDC


	.IF DF C$$XDJ		;XDT SUPPORTED ON KXJ

KXJNOT:	.WORD	0		;EQ 1 IF HOST IN ATTACHED MODE
				;EQ 0 IF HOST IN NOT ATTACHED

	.ENDC	; C$$XDJ

;
; THE FOLLOWING ITEMS MUST BE KEPT FROM COMMAND TO COMMAND.
;

T:	.BYTE	0		;T BIT IN USE FLAG
P:	.BYTE	-1		;PROCEED ALLOW FLAG
S:	.BYTE	0		;SINGLE INSTRUCTION MODE, 0=NORMAL, >0=ENABLE
FM:	.BYTE	2		;OUTPUT FORMAT MODE, BYTE, WORD, ANSII, RAD50
OBW:	.BYTE	2		;OPEN CELL TYPE, 1=BYTE, 2=WORD
SEQ:	.BYTE	0		;CHANGE SEQUENCE INDICATIOR


	.IF DF	K$$DAS	

DMODE:	.BYTE	'D,40		;MODE FLAG (I OR D) AND SPACE CHARACTER
REGFL:	.BYTE	0		;REGISTER BEING DISPLAYED FLAG (1=YES)
REGSV:	.BYTE	0		;SAVED REGFL FOR CHAINING
 
	.ENDC


	.EVEN

;
; THE BELOW LOCATION IS USED IN BREAKPOINT PROCESSING
;

TRTC:	BPT		;TRACE TRAP PROTOTYPE

;
; ALL XDT TYPE ERRORS JUST GO TO "ERR" OR SOMEWHERE ELSE
;

SSTXDT:	 +	ERR		;0-ODD ADDRESS
	 +	ERR		;1-SEGMENT FAULT
	 +	ERR		;2-BPT OR T-BIT ("MCR" CALL)
	 +	DCD		;3-IOT ("DECODE")
	 +	ERR		;4-RESERVED OR ILLEGAL INSTRUCTION
	 +	ERR		;5-EMT ("ERROR")
	 +	TYPE		;6-TRAP

;
; SST VECTOR ADDRESS TABLE
;

SSTADR:	.WORD	4		;ODD ADDRESS
	.WORD	250		;SEGMENT FAULT
	.WORD	14		;BPT
	.WORD	20		;IOT
	.WORD	10		;ILLEGAL INSTRUCTION
	.WORD	30		;EMT
	.WORD	34		;TRAP

;
; INTERNAL REGISTER NAME AND CONTROL TABLES
;
; NON-INDEXED REGISTER NAMES
;

NIXMAP:	.ASCII	/01234567/	;USER REGISTER NAMES FOR MAPPING

NIXREG:	.BYTE	'S		;UST	USER STATUS
	.BYTE	'A		;ARG	ARGUMENT
	.BYTE	'L		;LOW	LOW SCAN LIMIT
	.BYTE	'H		;HI	HIGH SCAN LIMIT
	.BYTE	'C		;CNST	CONSTANT
	.BYTE	'Q		;QUAN	QUANTITY
	.BYTE	'F		;FORM	FORMAT CONTROL
	.BYTE	0		;END OF THIS LIST

;
; INDEXED REGISTER NAMES
;

INXREG:	.BYTE	'B		;ADR1	BKPT ADDRESSES
	.BYTE	'G		;CT	BKPT PROCEED COUNTS
	.BYTE	'I		;UIN	BKPT USER INSTRUCTIONS
	.BYTE	'R		;RELT	RELOCATION REGISTERS
	.BYTE	0		;END OF THIS LIST

;
; INDEXED REGISTER TABLE BASES
;

	.EVEN
INXTBL:	.WORD	ADR1		;BKPT ADDRESS TABLE
	.WORD	CT		;BKPT PROCEED COUNTS
	.WORD	UIN		;BKPT'D INSTRUCTION
	.WORD	RELT		;RELOCATION TABLES
	.WORD	INTEND+2	;END OF TABLE AREA FOR ADDRESS MAPPING

;
; CHARACTER CONVERSION LISTS.
;

ALTTAB:	.BYTE	033,175,176	;ALTERNATE ALT-MODE FORMS
	.BYTE	0		;END OF THIS LIST TOO

;
; COMMAND NAME AND DISPATCH TABLES
;

COMTAB:		;ADDRESS OF THE CHARACTER TABLE

;
; OPEN REGISTER COMMANDS (ORDER AND POSITION CRITICAL)
;

	.BYTE	'\,'/,'','",'%

;
; CLOSE REGISTER COMMANDS
;

	.BYTE	015,012,'^,'_,'@,'>,'<

;
; SPECIAL FORMS
;

	.BYTE	'$,'=,'C,'Q,'.

;
; OPERATORS (ORDER OF -+* IS CRITCAL)
;

	.BYTE	';,'-,'+,'*,',

;
; COMMANDS
;

	.ASCII	/BGKLOPRSX/

 
	.IF DF	K$$DAS	
 
	.ASCII	/ID/		;INSTR MODE AND DATA MODE COMMANDS
 
	.ENDC
 
 
	.BYTE	0		;******* END OF THE LIST *******
	.EVEN

;
; THE DISPATCH TABLE, ORDERED ON ABOVE TABLE
;
; OPEN REGISTER COMMANDS
;

COMDIS:	.WORD	OCBYTE		;\	OPEN OCTAL BYTE
	.WORD	OCWORD		;/	OPEN OCTAL WORD
	.WORD	ANBYTE		;'	OPEN ANSII BYTE
	.WORD	ANWORD		;"	OPEN ANSII WORD
	.WORD	MODULO		;%	OPEN RADIX 50 WORD

;
; CLOSE REGISTER COMMANDS
;

	.WORD	CLCRET		;<CR>	CLOSE, NO SUCESSIVE OPEN
	.WORD	CLLNFD		;<LF>	CLOSE, OPEN NEXT
	.WORD	CLUPAR		;^	CLOSE, OPEN PREVIOUS
	.WORD	CLBACK		;_	CLOSE, OPEN PC RELATIVE MODE
	.WORD	CLATSG		;@	CLOSE, OPEN INDIRECT
	.WORD	CLGRTH		;>	CLOSE, OPEN PC OFFSET AS BRANCH
	.WORD	CLLSTH		;<	CLOSE, OPEN OLD SEQUENCE

;
; SPECIAL FORMS
;

	.WORD	REGT		;$	INTERNAL REGISTER REFERENCE
	.WORD	EQUALS		;=	PRINT LEFT SIDE IN OCTAL
	.WORD	CHRCEE		;C	CONSTANT REGISTER CONTENTS
	.WORD	CHRQUE		;Q	QUANTITY REGISTER CONTENTS
	.WORD	CHRDOT		;.	LAST OPENED LOCATION'S ADDRESS

;
; OPERATORS
;

	.WORD	SEMI		;;	MULTIPLE ARGUMENT DELIMITER
	.WORD	MINS		;-	SUBTRACTION
	.WORD	PLUS		;+	.WORD	ADDITION
	.WORD	STAR		;*	MULTIPLY BY 50
	.WORD	COMM		;,	RELOCATION COMPUTE

;
; COMMANDS
;

	.WORD	SEBK		;B	SET / CLEAR BREAKPOINTS
	.WORD	GOTO		;G	GO TO USER'S DATA
	.WORD	KILO		;K	KOMPUTE AND TYPE RELOCATION DATA
	.WORD	LIST		;L	LIST MEMORY ON SPECIFIED DEVICE
	.WORD	OFST		;O	TYPE PC RELATIVE OFFSETS
	.WORD	PROC		;P	PROCEED FROM BREAKPOINT
	.WORD	RELO		;R	SET / RESET RELOCATION REGISTERS
	.WORD	SNGL		;S	SET / RESET SINGLE STEP MODE
	.WORD	EXIT		;X	EXIT TO CRASH ROUTINE
 
 
	.IF DF	K$$DAS

	.WORD	INSTM		;I	SWITCH TO INSTR DISPLAY MODE
	.WORD	DATAM		;D	SWITCH TO DATA DISPLAY MODE

	.ENDC

	.SBTTL	INITIALIZATION
;+
; **-$XDT - RSX-11M-PLUS EXECUTIVE ODT
;-

	.ENABL	LSB
$XDT::	MOV	#PR7,PS		;LOCK OUT INTERRUPTS, CURR=PREV=KERNEL
	MOV	SP,USP		;SAVE ENTRY STACK POINTER
	MOV	#USP,SP		;SET NEW STACK POINTER ADDRESS
	MOV	R5,-(SP)	;SAVE REGISTERS R5 THRU R0
	MOV	R4,-(SP)	;
	MOV	R3,-(SP)	;
	MOV	R2,-(SP)	;
	MOV	R1,-(SP)	;
	MOV	R0,-(SP)	;
	MOV	PC,SP		;CHANGE STACK POINTER
	MOV	#SSTADR,R0	;POINT TO TRAP VECTOR ADDRESS TABLE
	MOV	#SSTXDT,R1	;POINT TO XDT TRAP VECTOR TABLE
10$:	MOV	(R1)+,@(R0)+	;INSERT XDT TRAP VECTOR ADDRESSES
	CMP	R1,#SSTADR	;ANY MORE TO SET?
	BLO	10$		;IF LO YES
 
 
	.IF DF	M$$PRO
 
	CMP	#$INITL,UPC	;SYSTEM BOOTED BEFORE?
	BEQ	20$		;NO, ALWAYS PROMPT (CANNOT USE $XDTFL
				;OR $XDTPR BECAUSE D-SPACE NOT SET UP
				;IF THIS IS AN I/D SPACE SYSTEM	
	BIS	$CPBIT,$XDTFL	;SHOW THIS CPU AS INITIALIZED
	BIT	$CPBIT,$XDTPR	;WANT AN XDT PROMPT?
	BNE	20$		;YES
	JMP	LEAVE		;NO, JUST RETURN TO CALLER
 
20$:				;
 
	.IF DF	K$$DAS

	CALL	SETRW		;SET I-SPACE DESCRIPTOR REGS TO RW
 
	.ENDC	
 
	.ENDC
 
 
	MOV	PC,SP		;LENGTHEN STACK
	TYPE	CRLF		;PLACE TERMINAL CARRIAGE IN PROPER POSITION
	TYPE	'X		;OUTPUT XDT IDENTIFICATION
	TYPE	'D		;
	TYPE	'T		;
	TYPE	':		;
	TYPE	40		;
	MOV	$SYSID,R0	;GET SYSTEM IDENTIFICATION
	TYPE	R0+R0		;OUTPUT SYSTEM IDENTIFICATION
	MOV	$SYSID+2,R0	;GET SECOND HALF OF IDENTIFICATION
	TYPE	R0+R0		;OUPUT IT, TOO !
	TYPE	CRLF		;PLACE TERMINAL CARRIAGE IN PROPER POSITION
	DECODE			;GET FIRST COMMAND
XDTSTK:				;REF LABEL - START OF XDT STACK

	.DSABL	LSB


	.IF DF	M$$PRO

$XDTIN::			;INITIALIZE XDT FOR THIS PROCESSO
	BIT	$CPBIT,$XDTFL	;THIS PROCESSOR ALREADY INITIALIZED?
	BEQ	10$		;NO
	RETURN			;
10$:	MOV	(SP)+,UPC	;RETURN TO CALLER WHEN DONE WITH XDT
	BR	$XDT		;
 
	.ENDC

	.SBTTL "$,<ALT-MODE>" PROCESSOR - INTERNAL REGISTER MAPPER

;SYNTAX--
;$L		DELIVER INTERNAL ADDRESS OF L
;$NL		DELIVER INTERNAL ADDRESS OF L+2N
;$N		DELIVER INTERNAL ADDRESS OF USER REGISTER N

;SEE MAPPING TABLES, RANGE OF N IS 0-7

REGT:	JSR	PC,GETNUM	;GET AN OCTAL NUMBER
	JSR	PC,RTST		;CHECK FOR ERROR
	BCC	5$		;R4 HAS BEEN MULTIPLIED BY 4
3$:	ERROR			;
5$:	TST	R2		;SEE IF ANYTHING TYPED
	BNE	10$		;IF SO IS INDEXED OR USER REGISTER
	JSR	R5,LOOKUP	;SEE IF NON-INDEXED
	 +	NIXREG
	BCS	12$		;NON-INDEXED TURNS INTO A COMMAND
	MOV	R1,R4		;PLACE IN LIST IS INTERNAL ORDER
	ADD	#UST,R4		;GET ADDRESS IN R4, GOTTA READ CHAR
	BR	20$
10$:	JSR	R5,LOOKUP	;SEE IF INDEXED
	 +	INXREG
	BCC	15$		;WAS TRULY INDEXED
12$:	CMP	#7+7,R4		;INTERNAL USER REGISTER RANGE CHECK
	BLO	3$
	ADD	#UR0,R4		;SET ACCESS TO R0-R7 OF THE USER
	BR	25$		;AVOID READING OF COMMAND
15$:	ADD	INXTBL(R1),R4	;COMPUTE ADDRESS TO INDEXED TABLE
20$:	JSR	PC,GET		;GET THE ASSUMED TERMINATOR
25$:	INC	R2		;SHOW THEM THAT R4 GOT VALID DATA
 
 
	.IF DF	K$$DAS	
 
	INCB	REGFL		;SET FLAG FOR REGISTER OPEN

	.ENDC


	JMP	CLGL		;RE-USE CHARACTER, R2 IS NON-ZERO

	.SBTTL "K" PROCESSOR - COMPUTE AND PRINT RELOCATION

;SYNTAX--
;AK				TYPE RELOCATION DEAL FROM DOT TO A
;L;AK				TYPE RELOCATION DEAL FROM L TO A

;IF A IS NULL THE THE OLD BEST FIT RULE APPLIES
;TYPES	=N,DDDDDD	WHERE N IS THE RELOCATION REGISTER
;				AND D-D IS THE RELOCATION BIAS

KILO:	TST	R2		;SEE WHO PICKS THE REGISTER
	BNE	10$
	TST	R3		; ADDRESS SPECIFIED?
	BNE	5$		; YES
	MOV	CAD,R4		; NO, GET CURRENT ADDRESS
	BR	7$		;
5$:	MOV	R5,R4		; GET ADDRESS SPECIFIED ON COMMAND
7$:	JSR	PC,LOCA		; GET CLOSEST RELOCATION REGISTER
	MOV	R0,R4		;DID WE FIND A RELOCATION REGISTER?
	BMI	ERR		;CAN'T FIND ONE THATS GOOD
10$:	BIC	#177770,R4	;EDIT REGISTER
	TYPE	'=		;OUTPUT CUE
	TYPE	40		;
	MOVB	R4,R0		;TYPE REGISTER & A ,
	ADD	#"0,,R0
	TYPE	R0+R0		;
	ASL	R4		;GO GET IT AS TABLE INDEX
	TST	R3		;SEE WHO TYPED THE ADDRESS
	BNE	15$
	MOV	CAD,R5		;THAT CAD!
15$:	SUB	RELT(R4),R5
	MOV	R5,R0		;BIAS COMPUTE
	JSR	PC,CADW		;PRINT AS WORD
	DECODE

	.SBTTL "A-Q-." PROCESSORS - SPECIAL VALUES

;MERELY SUBSTITUTE THE VALUE IN R4 WITH THE CONTENTS OF THE SPECIFIED
;REGISTER.

CHRQUE:	MOV	QUAN,R4		;LAST QUANTITY PRINTED
	BR	CHR001
CHRCEE:	MOV	CNST,R4		;CONSTANT REGISTER
	BR	CHR001
CHRDOT:	MOV	CAD,R4		;CURRENT LOCATION
CHR001:	INC	R2		;ALLOW AS R4 IS REAL
	JSR	PC,GET		;GET NEXT CHARACTER AND ASSUME
	BR	CLGL		;IT IS A TERMINATOR

	.SBTTL	COMMAND DECODER AND MAIN LOOP OF ODT

; COMMAND DECODER - ODT

;  ALL REGISTERS MAY BE USED (R0-R5),

;ERROR ENTRY, TYPE FLAG AND GO DO COMMAND

ERR:	CALL	SETCN		;SET OUTPUT FOR CONSOLE
	TYPE	'?		;OUTPUT ERROR INDICATION

;
; DECODE FROM THE TOP, CLOSE ALL AND DO CR/LF/_
;

DCD:	MOV	#XDTSTK,SP	;SET THE STACK FOR SANITY
	CALL	SETCN		;SET OUTPUT FOR CONSOLE
	TYPE	CRLF		;PLACE TERMINAL CARRIAGE IN PROPER POSITION
	CLR	OPN		;SET NO LOCATION OPEN
 

	.IF DF	K$$DAS
 
	CLRB	REGFL		;CLEAR REGISTER OPEN FLAG

	.ENDC

 
	TYPE	'X		;OUTPUT INPUT SOLICITATION
	TYPE	'D		;
	TYPE	'T		;
	TYPE	76		;'>'

;MAINTAIN OPENED LOCATION, RE-INIT INPUT

NEWC:	CLRB	SMFD		;CLEAR SEMI-COLON FLAG/COUNT
	CLR	R3		;ZERO SECONDARY ARGUMENT FLAG
	CLR	R5		;AND ARGUMENT

;NEW SUB-EXPRESSION ENTRY

NEWE:	CLRB	OP		;CLEAR OPERATOR FOUND
	CLR	EXP		;SET ZERO IN EXPRESSION SO FAR LOCATION

;GET NUMBER AND THEN SCAN FOR COMMAND

NEWN:	JSR	PC,GETNUM	;GET AN OCTAL NUMBER AND TERMINATOR

;NON-OCTAL CHAR TYPED WHAT ARE WE TO DO?

CLGL:	JSR	R5,LOOKUP	;GO SEE IF IT IS REAL
	 +	COMTAB		;THIS DEFINES REAL
	BCS	ERR		;EASY ENOUGH IF NOT REAL
	TST	R2		;IF NOTHING TYPE BOTHER NOT
	BEQ	CL01		;WITH THE EXPRESSION
	JSR	PC,EXPCOM	;COMPUTE EXPRESSION
CL01:	JMP	@COMDIS(R1)	;GO TO PROPER ROUTINE

;FOR THE BENEFIT ALL REGISTERS ARE AS FOLLOWS

;R0	LAST CHARACTER TYPED, THE COMMAND ITSELF!
;R1	TABLE INDEX TO COMMAND ADDRESSES, IT IS USED.
;R2,R4	FIRST ARGUMENT, IF R2<>0 THEN R4 IS DATA
;R3,R5	SECOND ARGUMENT, IF R3<>0 THEN R5 IS DATA

;
; SET OUTPUT DEVICE TO CONSOLE TERMINAL
;

SETCN:	MOV	#TPB,OUTB	;SET OUTPUT BUFFER ADDRESS
	MOV	#TPS,OUTS	;SET OUTPUT STATUS ADDRESS
	RETURN			;

	.SBTTL "\-/-'-"-%-:" PROCESSOR - OPEN AND TYPE CONTENT COMMANDS

;SYNTAX--
;NC				OPEN LOC N IN MODE C, SET MODE FOR NEXT
;C				TYPE LAST OPENED LOC IN MODE C

OCWORD:		;OCTAL WORD -		R1=2
ANWORD:		;ANSII WORD -		R1=6
MODULO:		;RADIX 50 WORD -	R1=10

;OPEN WORD MODE ENTRY, R1 CONTAINS FORMAT INDEX

	MOV	#2,R0		;SET BYTE FLAG TO WORD FLAG
	BR	OPE004		;GO TO IT ACE HOLE

OCBYTE:		;OCTAL BYTE -		R1=0
ANBYTE:		;ANSII BYTE -		R1=4

OPE001:	MOV	#1,R0		;SET WORD FLAG TO BYTE FLAG

OPE004:	TST	R2		;IF NO VALUE TYPED NO MODE SET
	BEQ	10$
	MOV	R0,BW		;SET MODE AND FORMAT FLAGS
	MOVB	R0,OBW		;SET THE LATER USE MODE
	MOVB	R1,FM		;SET THE MODE FLAG FOR SOOTH
	MOV	R4,CAD		;SET ADDRESS FOR EXPLICIT OPEN
	MOV	R4,DOT		;RESET RETURN PTR.
 
 
	.IF DF	K$$DAS

	MOVB	REGFL,REGSV	;INIT REGFL SAVE BYTE
 
	.ENDC
 
 
10$:	CMP	#1,R0		;CHECK ON BYTE MODE
	BEQ	15$		;NOT BYTE MODE
	BIT	#1,CAD		;SEE IF ADDRESS IS ODD
	BEQ	15$		;ALL IS GOOD
	CLR	R1		;THEY GET BYTE MODE ONLY
	BR	OPE001
15$:	MOV	R1,-(SP)	;SAVE FORMAT MAINLY
	JSR	PC,GETCAD	;GET THE DATA
	MOV	(SP)+,R1	;GET FORMAT
	JSR	PC,@TYFORM(R1)	;PRINT DATA IN PROPER FORMAT
	BR	NEWC		;GO GETTA NEW COMMAND TO DO

	.SBTTL	"<CR>-<LF>->-<-^-_-@" PROCESSOR - CLOSE AND OPEN REGISTERS
 
;CARRIAGE RETURN

CLCRET:	JSR	PC,PUTCAD	;CLOSE LOCATION
	DECODE			;RETURN TO DECODER

;LESS THAN, BACK TO MAIN STREAM

CLLSTH:	INCB	SEQ		;SET FLAG TO LATER RESTORE CAD

;LINE FEED, NEXT ONE DOWN

CLLNFD:	JSR	PC,PUTCAD	;CLOSE PRESENT CELL
	TSTB	SEQ		;SHOULD CAD BE RESTORED?
	BEQ	OP5		;BRANCH IF NOT
	MOV	DOT,CAD		;RESTORE PREVIOUS SEQUENCE


	.IF DF	K$$DAS	

	MOVB	REGSV,REGFL	;RESTORE REGISTER FLAG

	.ENDC


	CLRB	SEQ		;RESET FLAG; NO LONGER NEEDED
	BR	OP2A		;
OP5:	ADD	BW,CAD		;GENERATE NEW ADDRESS
OP2:	;MOV	CAD,DOT		;INITIALIZE DOT (REMOVED)
OP2A:	TYPE	CRLF		;PLACE CARRIAGE IN PROPER POSITION
	MOV	CAD,R0		;NUMBER TO TYPE
	JSR	PC,RORA		; CHECK FORMAT
	MOVB	FM,R0		;SET FORMAT
	ASR	R0		;SPLIT R0 IN HALF
	MOVB	COMTAB(R0),R0	;SET SUFFIX CHARACTER
	TYPE	R0		;PRINT CHARACTER
	MOV	CAD,R4		;SET UP THE DATA
	CLR	R2		; SET TO USE CAD ADDRESS
	CLRB	OP		;THIS IS BECUZE
	CLR	EXP
	JMP	CLGL		;R0 HAS TERMIN, R4- DATA, R2= FLAG

;UP ARROW, NEXT ONE UP

CLUPAR:	JSR	PC,PUTCAD
	SUB	BW,CAD		;GENERATE NEW ADDRESS
	BR	OP2		;GO DO THE REST

;BACK ARROW, PC RELATIVE COMPUTE

CLBACK:	JSR	PC,TCLS		;TEST WORD MODE AND CLOSE
	ADD	R4,R2		;COMPUTE
	CMPB	(R2)+,(R2)+	;NEW ADDRESS
PCS:	MOV	R2,CAD		;UPDATE CAD
	BR	OP2A		;GO FINISH UP

;AT SIGN, ABSOLUTE OR INDIRECT CHAIN

CLATSG:	JSR	PC,TCLS		;TEST WORD MODE AND CLOSE
	MOV	R4,R2		;GET ABSOLUTE ADDRESS
	BR	PCS

;GREATER THAN, PC OFFSET BRANCH ADDRESS

CLGRTH:	JSR	PC,TCLS		;TEST AND CLOSE
	MOVB	R4,R1		;COMPUTE NEW ADDRESS, EXTEND SIGN
	ASL	R1		;R2=2@R2)
	ADD	#2,R1		;+2
	ADD	R1,R2		;   +PC
	BR	PCS

;HANDY DANDY TO DO SOME LEG WORK

TCLS:	JSR	PC,PUTCAD	;CLOSE CURRENT CELL
	CMP	#2,BW		;ONLY WORD MODE ALLOWED
	BNE	ERR1		;BRANCH IF ERROR
	MOV	CAD,R2		;CURRENT ADDRESS IN R2
	MOV	R2,DOT		;MARK CURRENT POSITION
 
 
	.IF DF	K$$DAS	

	MOVB	REGFL,REGSV	;SAVE REGISTER FLAG
	CLRB	REGFL		;CLEAR OPEN REGISTER FLAG

	.ENDC


	RTS	PC

	.SBTTL "O" PROCESSOR - COMPUTE AND PRINT OFFSETS

;SYNTAX--
;AO				TYPE OFFSETS FROM . TO A
;L;AO				TYPE OFFSETS FROM L TO A

;TYPES	_PPPPPP >DDDDDD			WHERE P-P IS PC RELATIVE
;					AND D-D IS BRANCH OFFSET

OFST:	TST	R3		;HOW ABOUT A VALUE OTHER
	BNE	10$		;THAN CAD
	MOV	CAD,R5		;RELUCTANTLY
10$:	SUB	R5,R4
	SUB	#2,R4		;NO TRICKS, ODD AND NON-EXIST THINGS
	TYPE	'_		;TYPE PC RELATIVE CUE
	TYPE	40		;
	MOV	R4,R0
	MOV	R4,-(SP)	;GOOD IDEA TO SAVE THIS
	JSR	PC,CADW		;TYPE VALUE + BLANK
	TYPE	76		;TYPE OFFSET BRANCH CUE
	MOV	(SP)+,R0
	ASR	R0		;DIVIDE
OF09:	JSR	PC,CADW		;16 BITS SO YOU CAN SEE HOW FAR OFF
	DECODE			; GET NEXT COMMAND

	.SBTTL "=" PROCESSOR - PRINT LEFT SIDE EXPRESSION ON RIGHT SIDE

EQUALS:	MOV	R4,R0		;PROPER PRIOR PLANNING PREVENTS
	BR	OF09		;POOR PERFORMANCE

;JUST ANOTHER ERROR CALL

ERR1:	ERROR

	.SBTTL	SST INTERRUPT VECTOR ENTRY POINTS

;
; SEGMENT FAULT			- V1 - "MP" - NO PROCEED
;

SGMT:	TESTM	$SGFLT		;TEST IF IN EXEC MODE
	BIC	#160000,SR0	;UNFREEZE SEGMENT UNIT
	MOV	#"MP,EXP	;ENTRY PREFIX
	BR	NIXP		;

;
; STACK OVERFLOW		-    - "SO" - NO PROCEED
; ODD ADDRESS			- V0 - "OD" - NO PROCEED
; BPT				- V2 - "BE" - SPECIAL CASES
; T-BIT				- V2 - "TE" - PROCEED
; IOT				- V3 - "IO" - PROCEED
; RESERVED OR ILLEGAL		- V4 - "IL" - NO PROCEED
;

ODDA:	MOV	#"SO,EXP	;ASSUME STACK OVERFLOW
	CMP	SP,#V$$CTR+4	;STACK OVERFLOW?
	BLO	NIXP		;IF LO YES
	TESTM	$TRP04		;TEST IF IN EXEC MODE
	MOV	#"OD,EXP	;"OD:" FOR ODD ONE
	BR	NIXP		;NIX ON PROCEED
BPTI:	TESTM	$TRACE		;TEST IF IN EXEC MODE
	MOV	#"BE,EXP	;"BE:" FOR MAYBE A BAD ENTRY
	CLRB	P		;ALLOW PROCEED DEAL
	BR	INTR		;SPECIAL NUMBER FOR THIS ONE
IOTX:	TESTM	$IOTRP		;TEST IF IN EXEC MODE
	MOV	#"IO,EXP	;"IO:" FOR IOTEE
	BR	ALOP		;ALLOW PROCEED
ILLI:	TESTM	$ILINS		;TEST IF IN EXEC MODE
	MOV	#"IL,EXP	;"IL:" FOR ILL INSTRUCTION
NIXP:	MOVB	#-1,P		;NO PROCEED
	BR	INTR		;

;
; EMT				- V5 - "EM" - PROCEED
; TRAP				- V6 - "TR" - NO PROCEED
;

NEMT:	TESTM	$EMTRP		;TEST IF IN EXEC MODE
	MOV	#"EM,EXP	;"EM:" FOR EMTEE
ALOP:	MOVB	#BKP+2,P	;ALLOW PROCEED	

;
; COMMON INTERRUPT SERVICE AND DISPATCHER
;

INTR:	BIT	#TBT,2(SP)	;T-BIT SET IN STACKED PS WORD?
	BEQ	1$		;IF EQ NO
	CMP	PPC,(SP)	;PC CHANGE FROM LAST TRAP?
	BNE	1$		;IF NE YES
	JMP	RTN		;MUST HAVE HAD AN INTERRUPT BEFORE
				;THE INSTRUCTION HAD A CHANCE TO
				;EXECUTE.  AN INTERRUPT SERVICE	
				;ROUTINE EXITS WITH AN RTI.
1$:	MOV	(SP)+,UPC	;SET THE USER PC VALUE
	MOV	(SP)+,UST	;AND HIS ENTRY STATUS
	MOV	R0,UR0		;SAVE EXEC REGISTERS
	MOV	#UR0+2,R0	;POINT TO REGISTER SAVE AREA
	MOV	R1,(R0)+	;SAVE REGISTERS R1 THRU SP
	MOV	R2,(R0)+	;
	MOV	R3,(R0)+	;
	MOV	R4,(R0)+	;
	MOV	R5,(R0)+	;
	MOV	SP,(R0)+	;
	MOV	#XDTSTK,SP	;SET XDT STACK POINTER
 
 
	.IF DF	M$$PRO	
 
	CLR	-(SP)		;ASSUME SANITY TIMER IS NOT ENABLED
	BIT	$CPBIT,$STENB	;SANITY TIMER ENABLED FOR THIS CPU?
	BEQ	3$		;NO
	BIS	$CPBIT,(SP)	;SAVE CPU BIT
	BIC	(SP),$STENB	;WANT SANITY TIMER DISABLED
	CALL	$STTIC		;
3$:	MOV	(SP)+,STENB	;SAVE POLARITY OF SANITY TIMER BIT
 
	.ENDC


	MOV	#SSTADR,R0	;POINT TO TRAP VECTOR ADDRESS TABLE
	MOV	#SSTXDT,R1	;POINT TO XDT TRAP VECTOR TABLE
	MOV	#SSTVEC,R2	;POINT TO TABLE OF TRAP CONTENTS
5$:	MOV	@(R0),(R2)+	;SAVE THE CURRENT TRAP CONTENTS
	MOV	(R1)+,@(R0)+	;SET XDT TRAP VECTOR ADDRESSES	
	CMP	R1,#SSTADR	;ANY MORE TO SET?
	BLO	5$		;IF LO YES


	.IF DF	K$$DAS
 
	CALL	SETRW		;SET KERNEL INSTRUCTION DESCRIPTOR
				;REGISTERS TO READ/WRITE

	.ENDC
 

;TRY AND FIND OUT WHAT TO DO

	TSTB	P		;SEE IF CONTROLLED BREAKPOINT
	BNE	10$		;NOT DUE TO A PLANNED INTERRUPT
	TSTB	T		;IS A BPT OR T-BIT, SEE IF A PROCEED
	BNE	TBIT		;COMMAND IS BEING DONE, GO FINISH IT
	TSTB	S		;NO REMOVAL OF BREAKS ON S.I. MODE
	BNE	12$		;SKIP NEXT TWO WORDS

;
; REMOVE EXEC BREAKPOINTS
;

10$:	MOV	#ADR1,R4	;POINT TO BREAKPOINT VECTOR
 
 
	.IF DF	K$$DAS	
 
11$:	MOV	UIN-ADR1(R4),-(SP) ;PUSH CORRECT CONTENTS
	MTPI	@(R4)+		;REINSERT CORRECT CONTENTS

	.IFF

11$:	MOV	UIN-ADR1(R4),@(R4)+ ;REINSERT CORRECT CONTENTS

	.ENDC


	CMP	#ADR1+BKP,R4	;ANY LEFT TO RESTORE?
	BHIS	11$		;IF HIS YES
12$:	MOV	UPC,R5		;GET A COPY OF THE PC AT INTERRUPT
	TSTB	P		;BREAKPOINT OR T-BIT CHECK
	BNE	30$		;DEFINITELY NOT A BREAKPOINT
	MOVB	S,R4		;SEE IF SINGLE STEPPING
	BNE	22$		;AND PRETEND

;AT THIS POINT IT MAY BE DUE TO T-BIT OR A BPT

	MOVB	#BKP+2,P	;SET ALLOW TO THE 8'TH ONE
 

	.IF DF	K$$DAS
 
	MFPI	-(R5)		;GET TRAPPED INSTRUCTION FROM I-SPACE
	CMP	(SP)+,TRTC	;IS IT A BPT?

	.IFF
 
	CMP	-(R5),TRTC	;BACK-UP R5 AND SEE WHAT'S UP

	.ENDC

 
	BEQ	30$		;IT WAS A NON-BREAK BPT
	MOV	#BKP,R4		;SET ADDRESS OF LEGIT BREAKS
15$:	CMP	R5,ADR1(R4)	;LOOK IT UP IN THE TABLE
	BEQ	20$		;FOUND THE NASTY LITTLE BUGGER
	SUB	#2,R4		;KEEP AT IT
	BGE	15$		;UNLESS NO MORE
	MOV	#"TE,R4		;NOT THERE, MUST BE T-BIT ERROR
	TST	(R5)+		;RESET PC TO MAKE IT RIGHT
	BR	26$		;LABOR
20$:	MOV	R5,UPC		;BACK-UP PC FOR BREAKPOINT
22$:	MOVB	R4,P		;BREAKPOINT IS A REAL ONE
	DEC	CT(R4)		;CHECK OUT THE PROCEED COUNT
	BNE	31$		;LABOR ON A MIS-CONCEPTION
	INC	CT(R4)		;RESET PROCEED COUNT
	ASR	R4		;OCTAL TO UN-BIASED ASCII
	ADD	#"0B,R4		;BIAS TO ASCII
26$:	MOV	R4,EXP		;SET THE PREFIX UP

;COMMON TYPE ROUTINE FOR SST VECTORS USED UP

30$:	TYPE	CRLF		;PLACE CARRIAGE IN PROPER POSITION
	MOV	EXP,R0		;THE PREFIX
	TYPE	R0+R0		;
	TYPE	':		;
	MOV	R5,R0		;TYPE ADDRESS OF INTERRUPT
	JSR	PC,RORA		;AND THE REST OF THE ENTRY
	DECODE
31$:	JMP	C990		;BRANCH STRETCHER

	.SBTTL	"G, S, P" PROCESSORS - GO, SINGLE STEP, AND PROCEED
;
; "G" PROCESSOR - GO TO PROGRAM
;SYNTAX--
;LG			START PROGRAM AT LOCATION L
;G			START PROGRAM AT CURRENT PC

GOTO:	TST	R2		;SEE IF SPECIFIC ADDRESS
	BEQ	10$		;NO
	MOV	R4,UPC		;SET THE PC
10$:	CLRB	S		;NO SINGLE INSTRUCTIONS
TBIT:	CLRB	T		;CLEAR T-BIT FLAGS
	BIS	#TBT,UST	;BOTH
	TSTB	S		;SEE IF WE NEED A T-BIT BIT
	BNE	GRTT		;NO GO ON
	BIC	#TBT,UST	;SET THE TEE BIT

;
; SET EXEC BREAKPOINTS
;

10$:	MOV	#ADR1,R4	;POINT TO BREAKPOINT VECTOR

 
	.IF DF	K$$DAS	
 
20$:	MFPI	@(R4)		;SAVE CONTENTS OF LOCATION
	MOV	(SP),UIN-ADR1(R4) ;
	MOV	TRTC,(SP)	;PUSH BREAKPOINT INSTRUCTION
	MTPI	@(R4)+		;SET BREAKPOINT INSTRUCTION
 
	.IFF	
 
20$:	MOV	@(R4),UIN-ADR1(R4) ;SAVE CONTENTS OF LOCATION
	MOV	TRTC,@(R4)+	;SET BREAKPOINT

	.ENDC
 
	.IF DF	M$$PRO

	BIT	#1,SR0		;MAPPING ENABLED
	BEQ	24$		;IF EQ NO, CAN'T GET TO LOWCR'S

	.IF DF K$$DAS

	BIT	#4,SR3		;KERNEL D-SPACE ENABLED ?
	BEQ	24$		;IF EQ NO, CAN'T GET TO LOWCR'S

	.ENDC	; DF K$$DAS

	MOV	KISAR6,-(SP)	;SAVE CURRENT EXEC MAPPING
	MOV	R0,-(SP)	;AND A SCRATCH REGISTER
	MOV	UIN-ADR1(R4),-(SP) ;FETCH USER INSTRUCTION FOR UPDATES
	MOVB	$NCPU,R0	;GET NUMBER OF PROCESSORS
	ASL	R0		;AND CONVERT TO WORD INDEX
21$:	MOV	$K6TAB-2(R0),KISAR6 ;REMAP TO NEXT LOWCR
	MOV	(SP),140000+UIN-ADR1(R4) ;STUFF INSTRUCTION
	SUB	#2,R0		;POINT BACK TO NEXT CPU
	BGT	21$		;IF GT THERE IS ONE
	TST	(SP)+		;GET RID OF INSTRUCTION
	MOV	(SP)+,R0	;RESTORE SCRATCH REGISTER
	MOV	(SP)+,KISAR6	;RESTORE CURRENT EXEC MAPPING
24$:

	.ENDC	; DF M$$PRO

	CMP	#ADR1+BKP,R4	;ANY MORE TO INSERT?
	BHIS	20$		;IF HIS YES
 
GRTT:
 

	.IF DF	K$$DAS
 
	BIT	#1,SR0		;MAPPING ENABLED YET?
	BEQ	LEAVE		;IF EQ NO
	BIT	#4,SR3		;KERNEL DATA SPACE ENABLED YET?
	BEQ	LEAVE		;IF EQ NO
	MOV	#KINDR0,R0	;POINT TO KERNEL INSTR DESCR REG 0
25$:	BIC	#4,(R0)+	;SET RO ACCESS FOR EXEC
	CMP	R0,#KINDR7	;DONE YET?
	BLOS	25$		;IF LOS NO
 
	.ENDC

 
LEAVE:	CLR	OPN		;CLEAR LOCATION OPEN FLAG
	MOV	#SSTADR,R0	;POINT TO TRAP VECTOR ADDRESS TABLE
	MOV	#SSTVEC,R1	;POINT TO EXEC TRAP VECTOR TABLE
30$:	MOV	(R1)+,@(R0)+	;SET EXEC TRAP VECTORS
	CMP	R0,#SSTADR+<SSTADR-SSTXDT> ;ANY MORE TO SET?
	BLO	30$		;IF LO YES
 

	.IF DF	M$$PRO	
 
	BIS	STENB,$STENB	;POSSIBLY ENABLE SANITY TIMER
 
	.ENDC
 
	.IF DF C$$XDJ		;XDT SUPPORTED ON KXJ

	BIT 	#4,SR3		;IS KERNEL D SPACE ENABLED?
	BEQ 	40$		;IF EQ NO, THIS MUST BE VIRGIN BOOT NOT ON KXJ
	BIT	#F5.XDJ,$FMSK5  ;XDT ON KXJ?
	BEQ	40$		;IF EQ NO
	TST	KXJNOT		;HAS HOST BEEN NOTIFIED ALREADY
	BEQ	40$		;IF EQ YES

	MOV	$KXPTR,R0	;GET ADDRESS OF DCB
	MOV	D.UCB(R0),R0	;GET ADDRESS OF UCB
	MOV	U.SCB(R0),R0	;GET ADDRESS OF SCB
	MOV	S.KRB(R0),R0	;GET ADDRESS OF KRB
	MOV	K.CSR(R0),R0	;GET ADDRESS OF TPR0
	MOV	#RI$XDD,TPR2(R0) ;XDT DETACH CODE
	MOV	$KXVC1,R1	;GET ADDRESS OF FIRST VECTOR
	ADD	#4,R1		;GET ADDRESS OF XDT VECTOR
	MOV	R1,@#KXJQIR	;NOTIFY HOST OF DETACH
	
	CLR	KXJNOT		;KEEP TRACK OF DETACH OURSELVES
35$:	TST	TPR2(R0) 	;HOST RECEIVED DETACH MESSAGE?
	BNE	35$		;IF NE NO

	.ENDC	; C$$XDJ

40$:
 
	MOV	#UR0+2,R0	;POINT TO SAVED R1
	MOV	(R0)+,R1	;RESTORE REGISTERS R1 THRU SP THEN R0
	MOV	(R0)+,R2	;
	MOV	(R0)+,R3	;
	MOV	(R0)+,R4	;
	MOV	(R0)+,R5	;
	MOV	(R0)+,SP	;
	MOV	UR0,R0		;
	MOV	UST,-(SP)	;SET EXEC PS WORD
	MOV	UPC,-(SP)	;SET EXEC PC WORD
	MOV	(SP),PPC	;SET PREVIOUS PC WORD
RTN:	RTT			;RETURN TO EXECUTIVE

;
; "S" PROCESSOR - SINGLE STEP PROCEED
;SYNTAX--
;NS				EXECUTE N INSTRUCTIONS AND THEN STOP
;S				EXECUTE ONE INSTRUCTION

SNGL:	MOVB	#BKP+2,R0	;FAKE THE BREAK
	MOVB	R0,S		;SET THE FLAG FOR S.I. MODE
	BR	PR01		;FAKE A PROCEED IN S.I. MOOD

;
; "P" PROCESSOR - PROCEED FROM BREAKPOINT
;SYNTAX--
;NP				PROCEED THRU THIS BREAKPOINT N TIMES
;P				ASSUME N=1

PROC:	CLRB	S		;SET FAST MODE
	MOVB	P,R0		;GET NUMBER OF BREAK
	BMI	PR02		;THERE WASN'T ONE SO FAR ?
PR01:	TST	R2		;SEE IF VALUE IN R4 VIA R2
	BNE	10$		;SEE IF AND WHAT SETTING FOR COUNT
	MOV	#1,R4		;INIT IT TO ONE FOR A START
10$:	MOV	R4,CT(R0)	;SET USER'S COUNT
C990:	CMPB	P,#BKP		;SEE IF A REAL ONE OR A FAKE
	BGT	TBIT		;BRANCH IF FAKE
	TSTB	S		;SEE IF SINGLE INSTRUCTION MODE
	BNE	TBIT		;IF SO EXIT NOW
	INCB	T		;SET T-BIT FLAG
	BIS	#TBT,UST	;SET T-BIT
	BR	GRTT
PR02:	ERROR			;ANNOUNCE ERROR

	.SBTTL "L" PROCESSOR - LIST MEMORY ON THE SPECIFIED DEVICE

;SYNTAX--
; D;S;FL		WHERE	D IS DEV, <> OR 0 = CONSOLE, 1 = LPT
;				S IS START ADDRESS, SETS $L IF THERE
;				F IS STOP ADDRESS, SETS $H IF THERE

LIST:	TST	R2		;SET UPPER AND LOWER LIMITS
	BEQ	10$		;IF SPECIFIED TO DO SO
	MOV	R4,HI
10$:	TST	R3		;DO THE LOW ONE
	BEQ	15$
	MOV	R5,LOW
15$:	CMPB	#2,SMFD		;SEE IF AN EXTRA ARGUMENT
	BNE	17$		;USE THE CONSOLE
	TST	D.ARGS		;LOOK AT THE ARGUMENT
	BEQ	17$		;DO NOT ARGUE
	MOV	#LPS,OUTS	;SET OUTPUT STATUS REGISTER TO LINE PRINTER
	MOV	#LPB,OUTB	;
	TYPE	14		;OUTPUT A FORM FEED
17$:	MOV	LOW,R5		;GET STARTING DUMP ADDRESS
	MOVB	OBW,R0		;GET ADDRESS INCREMENT
	SUB	R0,R5		;BIAS ADDRESS BY ADDRESS INCREMENT
	MOV	R5,CAD		;SET CURRENT ADDRESS
	TST	-(SP)		;MAKE A HOLE IN THE STACK
20$:	CLR	(SP)		;NEW LINE UP
	JSR	PC,SNAGIT	;ACCESS DEVICE FOR DATA
	JSR	PC,SPRINT	;PRINT ADDRESS AND FIRST ITEM
25$:	JSR	PC,SNAGIT	;GET MORE DATA
	JSR	PC,DPRINT	;JUST PRINT THE DATA
	INC	(SP)		;COUNT THE DATA
	CMP	#7,(SP)		;CHECK THE COUNT
	BNE	25$		;JUST LIKE THEY TOLD YOU AT THE
	BR	20$		;FAMOUS PROGRAMMERS SCHOOL

	.SBTTL	"X" PROCESSOR - EXIT COMMAND
;
; EXIT COMMAND
;
; SYNTAX X
;
; THE EXIT COMMAND IN XDT EFFECTS A JUMP TO THE EXECUTIVE $CRASH ROUTINE.
;

EXIT:				;REFERENCE LABEL

	.IF DF C$$XDJ		;XDT SUPPORTED ON KXJ

	BIT 	#4,SR3		;IS KERNEL D SPACE ENABLED?
	BEQ 	10$		;IF EQ NO, THIS MUST BE VIRGIN BOOT NOT ON KXJ
	BIT	#F5.XDJ,$FMSK5  ;XDT ON KXJ?
	BEQ	10$		;IF EQ NO
	TST	KXJNOT		;HAS HOST BEEN NOTIFIED ALREADY
	BEQ	10$		;IF EQ YES

	MOV	$KXPTR,R0	;GET ADDRESS OF DCB
	MOV	D.UCB(R0),R0	;GET ADDRESS OF UCB
	MOV	U.SCB(R0),R0	;GET ADDRESS OF SCB
	MOV	S.KRB(R0),R0	;GET ADDRESS OF KRB
	MOV	K.CSR(R0),R0	;GET ADDRESS OF TPR0
	MOV	#RI$XDD,TPR2(R0) ;XDT DETACH CODE
	MOV	$KXVC1,R1	;GET ADDRESS OF FIRST VECTOR
	ADD	#4,R1		;GET ADDRESS OF XDT VECTOR
	MOV	R1,@#KXJQIR	;NOTIFY HOST OF DETACH
	CLR	KXJNOT		;KEEP TRACK OF DETACH OURSELVES
35$:	TST	TPR2(R0) 	;HOST RECEIVED DETACH MESSAGE?
	BNE	35$		;IF NE NO

	.ENDC	; C$$XDJ

10$:
	.IF DF C$$CDA

	MOV	#UR0+2,R0	;POINT TO SAVED R1
	MOV	(R0)+,R1	;RESTORE REGISTERS R1 THRU SP THEN R0
	MOV	(R0)+,R2	;
	MOV	(R0)+,R3	;
	MOV	(R0)+,R4	;
	MOV	(R0)+,R5	;
	MOV	(R0)+,SP	;
	MOV	UR0,R0		;
	MOV	UST,$CRUST	; MOVE USER PS FOR THE CRASH MODULE
	MOV	UPC,$CRUPC	; MOVE USER PC FOR THE CRASH MODULE
	JMP	$CRALT		; ALTERNATE ENTRY POINT TO THE CRASH MOD

	.IFF	; DF C$$CDA

	HALT			;HALT SYSTEM (MOSTLY USED IN P/OS

	.ENDC	; DF C$$CDA


	.SBTTL	UTILITIES - COMMAND SUPPORT ROUTINES

;TEST FOR VALID RELOCATION REGISTER IN R4

RTST:	CMP	#RLR/2,R4	;GET A GOOD NUMBER FOR A REGISTER
	BLO	10$		;NOT TOO GOOD, QUESTION IT
	ASL	R4
10$:	RETURN			;

;SNAG MEMORY LOCATION 	JSR PC,SNAGIT

;NEEDS--
;CAD		POINTS TO MEMORY WORD (APPROXIMATELY THAT IS)
;R0,R5		CONTAINS REAL WORD UPON EXIT TO "SRCHEK"

SNAGIT:	MOVB	OBW,R0		;SET THE INCREMENT
	ADD	R0,CAD		;INCREMENT AND NOW
	CMP	CAD,HI		;SEE IF MORE TO DO
	BLOS	10$		;IF NOT DO NOT
	DECODE			;GO RESET STACK AND NO NEXT COMMAND
10$:	JSR	PC,GETCAD	;ACCESS METHOD
	MOV	R0,R5		;MAKE A COPY FOR LATER
	RETURN			;

;SEARCH HIT PRINT			JSR PC,SPRINT

;CAD POINTS TO THE LOC TO BE PRINTED
;R5 CONTAINS THE CONTENTS OF THE LOCATION TO BE PRINTED

SPRINT:	TYPE	CRLF		;PLACE CARRIAGE IN PROPER POSITION
	MOV	CAD,R0		;THE LOCATION
	JSR	PC,RORA		;THE MODE
	MOVB	FM,R0		;PICK UP OLD CURENT MODE
	ASR	R0		;HALVES
	MOVB	COMTAB(R0),R0	;AH HA
	TYPE	R0		;TYPE THE MODE REGISTER

;DATA PRINT ROUTINE			JSR PC,DPRINT

;PRINTS DATA IN R5 IN CURRENT MODE

DPRINT:	MOVB	FM,R1		;SET THE MODE
	MOV	R5,R0		;THIS IS THE POOR DATA
	MOV	R5,-(SP)	;SAVE THE DATA
	JSR	PC,@TYFORM(R1)	;DO THAT __ TO THE POOR DATA
	MOV	(SP)+,R5	;RESTORE THE DATA
	RTS	PC		;RESTORE THE PC
 
 
;
; GET CHARACTER FROM CONSOLE TERMINAL
;

GET:
	.IF DF  C$$XDJ		;XDT SUPPORTED ON KXJ

	BIT 	#4,SR3		;IS KERNEL D SPACE ENABLED?
	BEQ 	5$		;IF EQ NO, THIS MUST BE VIRGIN BOOT NOT ON KXJ
	BIT	#F5.XDJ,$FMSK5 ;XDT ON KXJ?
	BNE	10$		;IF NE YES

	.IFTF   ; C$$XDJ

5$:
	TSTB	TKS		;CHARACTER READY?
	BPL	5$		;IF PL NO
	MOVB	TKB,R0		;READ INPUT BYTE

	.IFT	; C$$XDJ	

	BR	15$		;JOIN COMMON CODE
10$:	MOV 	$KXPTR,R0	;GET ADDRESS OF KXJ DCB
	MOV	D.UCB(R0),R0	;GET ADDRESS OF UCB
	MOV	U.SCB(R0),R0	;GET ADDRESS OF SCB
	MOV	S.KRB(R0),R0	;GET ADDRESS OF KRB
	MOV	K.CSR(R0),R0	;GET ADDRESS OF TPR0
	MOV	#100000,TPR3(R0) ;SET HIGH BIT
	MOV 	#RI$XDR,TPR2(R0) ;SET XDT READ FUNCTION CODE
	MOV	R0,-(SP)	;SAVE TPR0 ADDRESS
	MOV	$KXVC1,R0	;GET ADDRESS OF FIRST VECTOR
	ADD	#4,R0		;GET ADDRESS OF XDT VECTOR
	MOV	R0,@#KXJQIR	;NOTIFY HOST OF DETACH
	MOV	(SP)+,R0	;RESTORE R0
12$:	TST	TPR2(R0)	;HAS CHARACTER ARRIVED?
	BNE	12$		;IF MI NO
13$:	TST	TPR3(R0)	;SEE IF CPRSYS HAS GIVEN US THE CHAR
	BMI	13$		;IF MI, NOT YET
	MOV	TPR3(R0),-(SP)	;READ INPUT BYTE
	CLR	TPR3(R0) 	;CLEAR REGISTER
	MOV	(SP)+,R0	;GET CHARACTER
15$:
	.IFTF	; C$$XDJ


	.IF DF	R$$PRO

	MOV	#115,@#173202	;CLEAR THE PENDING INTERRUPT

	.ENDC	; DF R$$PRO

	BIC	#177600,R0	;CLEAR EXCESS BITS
	CMPB	R0,#12		;BRANCH IF <LF>
	BEQ	40$		;NO ECHO <LF>'S
	JSR	R5,LOOKUP	;CHECK IF ALTMODE
	+	ALTTAB
	BCS	20$		;
	MOVB	#'$,R0		;CHANGE TO $ IF SO
20$:	MOV	R0,-(SP)	;SAVE INPUT CHARACTER
	TYPE	R0		;ECHO CHARACTER
	MOV	(SP)+,R0	;RESTORE INPUT CHARACTER
	CMP	#141,R0		;LOWER CASE CHARACTER?
	BHI	30$		;IF HI NO
	CMP	#172,R0		;LOWER CASE CHARACTER?
	BLO	30$		;IF LO NO
	SUB	#40,R0		;CONVERT TO UPPER CASE CHARACTER
30$:	CMPB	#' ,R0		;CVT BLANK
	BNE	40$
	MOVB	#'+,R0		;INTO +
40$:	RETURN			;

;
; TYPE CHARACTER ON OUTPUT DEVICE
;

TYPE:	MOV	(SP),-(SP)	;DUPLICATE RETURN ADDRESS
	SUB	#2,(SP)		;POINT TO TRAP INSTRUCTION
	MOVB	@(SP)+,-(SP)	;GET LOW BYTE OF INSTRUCTION
	BMI	10$		;IF MI CONTROL BYTE
	MOV	(SP)+,R0	;SET BYTE TO OUTPUT
	BR	30$		;
10$:	BIT	#40,(SP)	;OUTPUT CONTENTS OF R0?
	BEQ	20$		;IF EQ YES
	MOV	(PC)+,R0	;SET TO OUTPUT <CR><LF>
	.BYTE	15,12		;
20$:	ASLB	(SP)+		;OUTPUT TWO BYTES?
	BPL	30$		;IF PL NO
	TYPE	R0		;TYPE OUT FIRST BYTE
	SWAB	R0		;SET UP HIGH BYTE
30$:
	.IFT	; C$$XDJ

	BIT 	#4,SR3		;IS KERNEL D SPACE ENABLED?
	BEQ 	31$		;IF EQ NO, THIS MUST BE VIRGIN BOOT NOT ON KXJ
	BIT	#F5.XDJ,$FMSK5 ;XDT ON KXJ?
	BNE	45$		;IF NE YES
	
	.IFTF	; C$$XDJ

31$:	TSTB	@OUTS		;OUTPUT DEVICE READY?
	BPL	31$		;IF PL NO
	MOVB	R0,@OUTB	;OUTPUT BYTE
35$:	TSTB	@OUTS		;OUTPUT DEVICE READY?
	BPL	35$		;IF PL YES
	CMPB	#15,R0		;WAS OUTPUT BYTE A CARRIAGE RETURN?
	BNE	50$		;IF NE NO
	CMP	#LPS,OUTS	;OUTPUT DEVICE LINE PRINTER?
	BEQ	50$		;IF EQ YES
	MOV	#5,-(SP)	;SET FILL COUNT TO 5
	CLRB	R0		;SET OUTPUT NULLS
40$:	TYPE	R0		;OUTPUT A NULL
	DEC	(SP)		;ANY MORE TO OUTPUT?
	BGT	40$		;IF GT YES
	TST	(SP)+		;CLEAN STACK

	.IFT	; C$$XDJ

	BR	50$		;JOIN COMMON CODE
45$:	
	MOV	R0,-(SP)	;SAVE CHARACTER
	MOV 	$KXPTR,R0	;GET ADDRESS OF KXJ DCB
	MOV	D.UCB(R0),R0	;GET ADDRESS OF UCB
	MOV	U.SCB(R0),R0	;GET ADDRESS OF SCB
	MOV	S.KRB(R0),R0	;GET ADDRESS OF KRB
	MOV	K.CSR(R0),R0	;GET ADDRESS OF TPR0
	TST	KXJNOT		;HAVE WE ALREADY NOTIFIED HOST FOR ATTACH?
	BNE	455$		;IF NE, YES
	MOV	#1,KXJNOT	;SET NOTIFICATION FLAG
	MOV	#RI$XDA,TPR2(R0) ;ATTACH CODE
	MOV	R0,-(SP)	;SAVE TPR0 ADDRESS
	MOV	$KXVC1,R0	;GET ADDRESS OF FIRST VECTOR
	ADD	#4,R0		;GET ADDRESS OF XDT VECTOR
	MOV	R0,@#KXJQIR	;NOTIFY HOST OF DETACH
	MOV	(SP)+,R0	;RESTORE TPR0 ADDRESS		
453$:	TST	TPR2(R0)	;HOST RECEIVED ATTACH MESSAGE?
	BNE	453$		;IF NE NO
455$:	
	MOV	(SP),TPR3(R0)	;OUTPUT BYTE
	MOV	#RI$XDW,TPR2(R0) ;SET WRITE FUNCTION CODE
	MOV	R0,-(SP)	;SAVE TPR0 ADDRESS
	MOV	$KXVC1,R0	;GET ADDRESS OF FIRST VECTOR
	ADD	#4,R0		;GET ADDRESS OF XDT VECTOR
	MOV	R0,@#KXJQIR	;NOTIFY HOST OF DETACH
	MOV	(SP)+,R0	;RESTORE TPR0 ADDRESS
46$:	TST	TPR2(R0)	;CHARACTER RECEIVED?
	BNE	46$		;IF MI NO
	MOV	(SP)+,R0	;RESTORE CONTENTS OF R0

	.ENDC	; C$$XDJ

50$:	RTI			;

	.SBTTL	UTILITIES - PRETTY PRINTERS

;PRINT ADDRESS- RELOC, SYMBOLIC, OR ABSL	JSR PC.RORA

;R0	ADDRESS TO BE PRINTED
;FORM	CORE ADDRESS FORMAT (0-RELOC  1-ABSOL)

;REGISTER	'$R ' OR '$DR '
;CORE		'D,XXXXXX ' OR 'XXXXXX '

RORA:	MOV	R0,-(SP)	;CALLING VALUE ONA TOPPA SATCK
 
 
	.IF DF	K$$DAS	

	MOV	DMODE,R0	;PICK UP MODE CHARACTER AND SPACE
	TSTB	REGFL		;ATTEMPT TO OPEN REGISTER?
	BEQ	50$		;IF EQ NO
	MOV	#"D ,R0		;DATA SPACE USED IF REGISTER NOT THERE
 
	.IFTF

	CMP	#INTBEG,(SP)
	BHI	50$		;BELOW FIRST NON-INDEXED
	CMP	#INTEND,(SP)
	BLO	50$		;ABOVE LAST NON-INDEXED
	TYPE	'$		;ANNOUNCE INTENSIONS
	CMP	#INTINX,(SP)
	BLOS	20$		;GO TO DO INDEXED
	MOV	(SP)+,R0	;NON-INDEXED REGISTER ----- "$R "
	SUB	#INTBEG,R0	;CLEANED UP STACK, GET OFFSET
	ASR	R0		;BYTE THAT WORD, WORD THAT BYTE
	MOVB	NIXMAP(R0),R0	;MAGIC CHARACTER FROM TABLE
15$:	BIS	(PC)+,R0
	.BYTE	000,' 		;CHARACTER PLUSSA BLANK
	TYPE	R0+R0		;NAME PLUS BLANK AND SPLIT
	RETURN			;
20$:	CLR	R1		;SEE WHICH SET OF TABLES WE GOT
22$:	CMP	INXTBL+2(R1),(SP) ;LOOK ON AHEAD TO FIND BEHIND
	BHI	24$		;R1 POINTS TO BASE OF SET
	TST	(R1)+		;THINK ABOUT THOSE DUMMY ENTRIES DUMMY
	BR	22$
24$:	MOV	(SP)+,R0	;INDEXED REGISTER ---- "$DR "
	SUB	INXTBL(R1),R0	;GET ADDRESS AND COMPUTE OFFSET IN WORDS
	ASR	R0		;AND FINALLY IN PLAIN TALK
	ADD	#'0,R0		;CONVERT TO ASCII
	TYPE	R0		;TYPE OUT REGISTER NUMBER
	ASR	R1
	MOVB	INXREG(R1),R0	;PICK UP THE REAL CHARACTER
	BR	15$		;GO PRINT REST OF IT
50$:				;REF LABEL
 
	.IFT	

	TST	OPN		;IS A LOCATION OPEN?
	BEQ	60$		;IF EQ NO
	TYPE	R0+R0		;OUTPUT MODE INFO
60$:				;
 
	.ENDC
 

	TST	FORM		;CORE ADDRESS SEE WHAT USER WANTS
	BNE	80$		;TYPE AS ABSOLUTE.
	MOV	(SP),R4		;RELOCATE ---- "R,XXXXXX "
	JSR	PC,LOCA		;WE ALWAYS PICK, XDT KNOWS BEST
	BMI	80$		;BUT NOT ALL THE TIME
	MOV	R1,(SP)		;SET THE DISPLACEMENT
	ADD	#"0,,R0		;PRINT REGISTER AND COMMA
	TYPE	R0+R0		;DISK AND CORE
80$:	MOV	(SP)+,R0	;PRINT R0 AS A WORD

;TYPE R0 AS BYTE OR WORD, TWO ENTRIES
;	FOR A WORD				JSR PC,CADW
;	FOR A BITE				JSR PC,CADB

CADW:	MOV	R0,QUAN		;SET THE FAMOUS QUANTITY VALUE
	MOV	#6,R3		;# OF DIGITS
	MOV	#-2,R4		;# OF BITS FIRST-3
	BR	CA01		;DO THE COMMON THING
CADB:	CLR	QUAN		;SET FOR ALL OF QUAN A BYTE
	MOVB	R0,QUAN		;SET THE QUANTITY THING AGAIN
	MOV	#3,R3		;THERE ARE THREE DIGITS
	MOV	#-1,R4		;AND ONLY TWO BITS
	SWAB	R0		;SWITCH ENDS
CA01:	MOV	R0,-(SP)	;SAVE R0
10$:	ADD	#3,R4		;COMPUTE THE NUMBER OF BITS TO DO
	CLR	R0
15$:	ROL	(SP)		;GET A BIT
	ROL	R0		;STORE IT AWAY
	DEC	R4		;DECREMENT COUNTER
	BGT	15$		;LOOP IF MORE BITS NEEDED
	ADD	#'0,R0		;CONVERT TO ASCII
	TYPE	R0		;TYPE IT
	DEC	R3		;SEE IF MORE DIGITS TO DO
	BGT	10$		;LOOP IF SO
	MOVB	#' ,R0		;SET UP FOR TRAILING SPACE
	TST	(SP)+		;GET RID OF JUNK
	TYPE	R0		;
	RETURN			;
 
 
;TYPE CONTENTS OF WORD IN FORMAT	JSR PC,@TYFORM(R1)

;R0		WORD OR BYTE TO BE TYPED, RHJ
;R1	CODE-	ENTRY PT,	FORMAT,	CODE

TYFORM:	+	CADB		;BYTE OCTAL - 0
	+	CADW		;WORD OCTAL - 2
	+	30$		;BYTE ANSII - 4
	+	20$		;WORD ANSII - 6
	+	10$		;RADIX 50  - 10

10$:	JSR	PC,TYRADX	;R0 GETS THE RADIX 50 TREATMENT
	BR	35$		;APPEND A BLANK TO 3 CHAR'S

20$:	TYPE	R0		;TYPE BYTE IN R0
	SWAB	R0		;SWAP EM AND TYPE IT
30$:	TYPE	R0		;TYPE BYTE IN R0
35$:	TYPE	40		;TYPE A SPACE
	RETURN			;

;TYPE CONTENTS OF R0 IN RADIX 50		JSR PC,TYRADX

TYRADX:	MOV	#3,R5		;COUNT OF CHARACTERS
	MOV	#50$,R2		;POINTER TO COEFFICENT TABLE
	MOV	R0,R1		;COPY OF RADIX 50 WORD
10$:	MOV	R1,R0		; GET DIVIDEND
	MOV	(R2)+,R1	; GET DIVISOR
	JSR	PC,$DIV		; DIVIDE, R0=QUOTIENT, R1 =REMAINDER
	TST	R0		; IS QUOTIENT ZERO? (SP)?
	BEQ	12$		;"SP" = 040
	CMPB	R0,#33		;RAD50-$ =33
	BEQ	16$		;"$" = 044
	BGT	14$		;"." OR "0-9" = 056 OR 060-071
	ADD	#40,R0		;RAD50-A = 1, "A" = 101
12$:	ADD	#16,R0		;40+16+11+11 = 100 + (A-Z)
14$:	ADD	#11,R0		;16+11+11 = 40 + (SP)
16$:	ADD	#11,R0		;11+11 = 22 + (.,0-9)
	TYPE	R0		;TYPE CHARACTER IN R0
	DEC	R5		;COUNT THE CHARACTERS
	BNE	10$		; LOOP
	RTS	PC

;COEFFICENT TABLE, RADIX 50 CONVERT

50$:	.WORD	+1600.,+40.,+1.	;40.^2, 40.^1, 40.^0

	.PAGE
	.SBTTL "I" AND "D" PROCESSOR - SET INSTR OR DATA DISPLAY MODE

;SYNTAX--
;I			SET INSTR DISPLAY MODE
 
 
	.IF DF	K$$DAS
 
INSTM:	MOVB	#'I,DMODE	;SET FOR INSTRUCTION DISPLAY MODE
	DECODE			;DECODE NEXT COMMAND
 
;SYNTAX--
;D			SET DATA DISPLAY MODE	
 
DATAM:	MOVB	#'D,DMODE	;SET FOR DATA DISPLAY MODE
	DECODE			;DECODE NEXT COMMAND
 
	.ENDC



	.SBTTL "B" PROCESSOR - SET AND REMOVE BREAKPOINTS

;SYNTAX--
;B			CLEAR ALL BREAKPOINTS
;NB			CLEAR BKPT N
;A;B			SET BKPT AT A, USE FIRST FREE  BKPT
;A;NB			SET BKPT N AT A

;DEPENDS MIGHTILY UPON LOCATION "TRTC" CONTAINING A TRAP INST.
;AND THAT A FREE BKPT CONTAINS THE ADDRESS "TRTC".

SEBK:	ASL	R4		;MPY R4 X2, JUST IN CASE ALL IS GO
	MOV	#TRTC,R0	;SET MAGIC VALUE IN R0, JUST IN CASE
	TST	R3		;CHECK FOR THE REAL CASE
	BEQ	REMB		;REMOVAL CASES, CLEAR THEM UP
	BIT	#1,R5		;LOOK AT ADDRESS
	BNE	ERR0		;THAT'S ODD ?
	TST	R2		;SEE IF I GET TO PICK IT OR NOT
	BNE	15$		;OR NOT, DISAPPOINTMENT
10$:	CMP	R0,ADR1(R4)	;LOOK FOR LOCATION WITH FREE ADDRESS
	BEQ	15$		;A HIT
	TST	(R4)+		;KEEP AT FOR A LONG WHILE
	BR	10$		;LOOOOOOOOP
15$:	MOV	R5,R0		;R0 HAS ADDRESS OF BREAKPOINT
	BR	RE02		;GO TUCK IT IN

;REMOVE SOME BREAKPOINTS

REMB:	TST	R2		;SEE IF ONE OR ALL
	BEQ	RALL		;ALL
RE02:	JSR	PC,SETBRK	;SET THE ONE SET UP TO SET
	BCC	RALL2		;IT HAPPENED
ERR0:	ERROR			;SOME THING WENT WRONG

;
; REMOVE ALL BREAKPOINTS
;

RALL:	CLR	R4		;R4 IS ZERO
10$:	JSR	PC,SETBRK	;SET THEM TILL
	BCC	10$		;THEY GET OUTTA
RALL2:	DECODE			;HAND!!!!

;
; SUBROUTINE TO SET/CLEAR BREAKPOINTS
;

SETBRK:	CMP	#BKP,R4		;LEGAL BREAKPOINT NUMBER?
	BLO	10$		;IF LO NO

	.IF DF	M$$PRO

	BIT	#1,SR0		;MAPPING ENABLED ?
	BEQ	8$		;IF EQ NO, CAN'T GET TO LOWCR'S

	.IF DF	K$$DAS

	BIT	#4,SR3		;KERNEL D-SPACE ENABLED ?
	BEQ	8$		;IF EQ NO, CAN'T GET TO LOWCR'S

	.ENDC	; DF K$$DAS

	MOV	KISAR6,-(SP)	;SAVE CURRENT EXEC MAPPING
	MOV	R0,-(SP)	;AND BREAKPOINT ADDRESS
	MOVB	$NCPU,R0	;GET NUMBER OF PROCESSORS
	ASL	R0		;CHANGE TO WORD INDEX
5$:	MOV	$K6TAB-2(R0),KISAR6 ;REMAP TO NEXT LOWCR
	MOV	(SP),140000+ADR1(R4) ;SET BREAKPOINT ADDRESS
	MOV	#1,140000+CT(R4) ;AND INITIAL PROCEED COUNT
	SUB	#2,R0		;POINT BACK TO NEXT CPU
	BGT	5$		;IF GT THERE IS ONE
	MOV	(SP)+,R0	;RESTORE BRAKPOINT ADDRESS
	MOV	(SP)+,KISAR6	;RESTORE CURRENT EXEC MAPPING
	BR	9$

8$:
	.ENDC	; DF M$$PRO

	MOV	R0,ADR1(R4)	;SET BRAEKPOINT ADDRESS
	MOV	#1,CT(R4)	;SET INITIAL PROCEED COUNT

9$:	TST	(R4)+		;ADVANCE BREAKPOINT NUMBER
10$:	RETURN			;

	.SBTTL "R" PROCESSOR - RELOCATION REGISTER PROCESSING

;DETERMINE IF CLEAR OR SET

RELO:	TSTB	SMFD		;SEMI-COLON ABSENT MEANS CLEAR
	BEQ	10$		;CLEAR DISPATCH, OR FALL TO SETTING

;FORMS HERE--
; A;NR			SET RELOC(N) TO A
;ABSENT A OR N DEFAULTS TO 0

	JSR	PC,RTST		;PROTECTION EDITING
	BCS	ERR0		;ILLEGAL REGISTER NUMBER ?

	.IF DF M$$PRO
	
	BIT	#1,SR0		;MEMORY MANAGEMENT ENABLED ?
	BEQ	5$		;IF EQ NO, CAN'T GET TO LOWCRS

	.IF DF K$$DAS

	BIT	#4,SR3		;KERNEL DATA SPACE ENABLED ?
	BEQ	5$		;IF EQ NO, CAN'T GET TO LOWCRS

	.ENDC	; DF K$$DAS

	MOV	KISAR6,-(SP)	;SAVE CURRENT EXEC MAPPING
	MOV	R0,-(SP)	;SAVE WORKING REGISTER
	MOVB	$NCPU,R0	;GET NUMBER OF CPUS
	ASL	R0		;MAKE WORD INDEX
3$:	MOV	$K6TAB-2(R0),KISAR6 ;MAP TO NEXT PROCESSORS LOWCR
	MOV	R5,140000+RELT(R4)  ;AND SET RELOCATION REGISTER
	SUB	#2,R0		;POINT BACK TO NEXT PROCESSOR
	BGT	3$		;IF GT MORE TO GO
	MOV	(SP)+,R0	;RESTORE WORKING REGISTER
	MOV	(SP)+,KISAR6	;RESTORE EXEC MAPPING
	DECODE			;GO GET NEXT COMMAND
5$:				;REF LABEL

	.ENDC	; DF M$$PRO

	MOV	R5,RELT(R4)	;SET THE APPROPRIATE REGISTER
	DECODE			;GO GET NEXT COMMAND

;FORMS HERE--
;R			RESET ALL TO -1 FOR RELOC(0-7)
;NR			RESET ONLY RELOC(N)

10$:	TST	R2		;SEE IF NR OR JUST R
	BEQ	15$		;CLEAR ALL
	JSR	PC,RUCL		;CLEAR THE ONE IN R4
	BCS	ERR0		;ERROR, INVALID REGISTER ?
	DECODE			;NEXT COMMAND
15$:	JSR	PC,RUAL		;DO THEM ALL
	DECODE			;OFF AND ON

;
; SUBROUTINE TO RESET RELOCATION BASE REGISTER
;

	.ENABL	LSB
RUCL:	CALL	RTST		;TEST FOR LEGAL REGISTER
	BCS	10$		;IF CS ILLEGAL REGISTER
	MOV	#-1,RELT(R4)	;RESET RELOCATION REGISTER
	ASR	R4		;CONVERT BACK TO REGISTER NUMBER
10$:	RETURN			;

;
; SUBROUTINE TO CLEAR ALL RELOCATION REGISTERS
;

RUAL:	CLR	R4		;START WITH REGISTER 0
20$:	CALL	RUCL		;CLEAR NEXT RELOCATION REGISTER
	BCS	10$		;IF CS ALL DONE
	INC	R4		;ADVANCE TO NEXT REGISTER
	BR	20$		;
	.DSABL	LSB

	.SBTTL	EXPRESSION SETUP COMMANDS ( ; + - * , )

;SEMI-COLON PROCESSOR

SEMI:	INCB	SMFD		;COUNT SEMI-COLON
	CMPB	#2,SMFD		;PUSH CONTENTS INTO MULTI
	BNE	SEM1		;SEMI COLON ARG LIST
	MOV	R5,D.ARGS
SEM1:	MOV	R2,R3		;PUSH R2 AND R4 INTO
	MOV	R4,R5		;R3 AND R5 (FLAG AND CONTENTS)
	JMP	NEWE		;CONTINUE SCANNER

;ADDITION SETUP

PLUS:	CLRB	OP		;OP IS 0 FOR +
	BR	CO00

;SUBTRACT SET UP

MINS:	MOVB	#2,OP
	BR	CO00

;MULTIPLY BY 50 AND ADD

STAR:	MOVB	#-2,OP		;OP IS -2 FOR *
CO00:	CLR	R4		;R4 IS RESET
	JMP	NEWN

;MEMORY RELOCATION CHECK

COMM:	ASL	R4		;ALL NEED IT X 2
	CMP	R4,#RLR		;SEE IF REGISTER IS OUT OF RANGE
	BGT	ERR2
	MOV	RELT(R4),EXP	;COMPUTE REAL CORE ADDRESS
	BR	PLUS
ERR2:	ERROR			;OOPS

	.SBTTL	MISCELLANEOUS SUBROUTINES
;
; TEST IF IN EXEC MODE
;

TESTM:	MOV	(R5)+,-(SP)	;PICK UP EXEC TRAP ROUTINE ADDRESS
	TST	$STKDP		;ALLOW EXEC TO HANDLE TRAP?
	BGT	20$		;IF GT YES, TRAP WAS IN USER MODE
	BLT	10$		;IF LT NO, BAD STACK DEPTH
	CMP	4(SP),#$DRLM1	;TRAP OCCUR IN DIRECTIVE DISPATCHER?
	BLO	5$		;IF LO NO
	CMP	4(SP),#$DRLM2	;TRAP OCCUR IN DIRECTIVE DISPATCHER?

	.IF NDF	D$$PAR

	BLOS	20$		;IF LO YES, PASS TRAP TO EXEC

	.IFF	; NDF D$$PAR

	BHI	5$		;IF HI NO
	CMP	KINAR5,$DRAPR	;IS THE DISPATCHER MAPPED
	BEQ	20$		;IF EQ YES, PASS TRAP TO EXEC

	.ENDC	; NDF D$$PAR

5$:
	.IF DF	D$$PAR

	CMP	KINAR5,$DRAP2	;2ND DIRECTIVE COMMON MAPPED
	BNE	10$		;IF NE NO, XDT HANDLES TRAP

	.ENDC	; DF D$$PAR

	CMP	4(SP),#$DQLM1	;TRAP OCCUR IN QIO DIRECTIVE ?
	BLO	10$		;IF LO NO
	CMP	4(SP),#$DQLM2	;TRAP OCCUR IN QIO DIRECTIVE?
	BLOS	20$		;IF LOS YES, ALLOW EXEC TO HANDLE TRAP
10$:	MOV	R5,(SP)		;SET TO XDT ADDRESS
20$:	MOV	(SP)+,R5	;SET RETURN ADDRESS
	RTS	R5		;PROCESS TRAP
 
 
;EXPRESSION COMPUTATION ROUTINE		JSR PC,EXPCOM

;NEEDS--
;OP			THE OPERATION (-2=*, 0=+, *=2)
;EXP			THE LEFT SIDE
;R4			THE RIGHT SIDE

;SETS UP--
;OP			BACK TO 0 FOR ADD
;EXP,R4		ALL SO FAR

EXPCOM:	TSTB	OP		;SEE WHAT'S UP CHUCK
	BMI	20$
	BEQ	10$
	NEG	R4		;MINUS, OP=2
10$:	ADD	EXP,R4		;PLUS, OP=0
15$:	MOV	R4,EXP		;COMMON OUT, SET EXP TO WHATEVER
	CLRB	OP		;IS IN R4 TOO
	INC	R2		;SET R2 SO THAT R4 IS, OP=0
	RTS	PC
20$:	MOV	EXP,-(SP)	;GET THE LEFT SIDE OF EXPRESSION
	ASL	(SP)		; MULTIPLY BY 10
	ASL	(SP)		;
	ASL	(SP)		;
	ADD	(SP),R4		; ADD IT
	ASL	(SP)		; MULTIPLY BY 40
	ASL	(SP)		; WHICH IS LIKE MULTIPLYING BY 50
	ADD	(SP)+,R4	;AND ADD IT TO THE RIGHT
	BR	15$		;COMMON OUT
 
 
;BUILD AN OCTAL NUMBER		JSR PC,GETNUM

;NEEDS AND RETURNS--
;R0	NON-OCTAL TERMINATING CHARACTER
;R2	OCTAL CHARACTER COUNT
;R4	OCTAL NUMBER THAT I GOT, YOU GET

GETNUM:	CLR	R2		;NEW R2 AND R4
	CLR	R4
10$:	JSR	PC,GET		;GET 1 CHARACTER
	CMPB	#'0,R0		;NON-OCTAL, LESS THAN "0"
	BHI	GETC99
	CMPB	#'7,R0		;NON-OCTAL, LESS THAN "7"
	BLO	GETC99
	BIC	#177770,R0	;MAKE INTO ACCEPTABLE RANGE
	ASL	R4		; SHIFT LEFT
	ASL	R4		; 3 BITS
	ASL	R4		;
	ADD	R0,R4		;PLANT LO PLACE
	INC	R2		;ACCOUNT FOR NEW ONE
	BR	10$		;NEXT ONE OR OTHER

;SCAN A LIST OF CHARACTERS	JSR R5,LOOKUP

;CALL--
;		R0	HAS THE CHARACTER
;	JSR	R5,LOOKUP	;THAT IS IT
;	 +	LIST TO USE, 00 BYTE IS END OF LIST

;RETURNS AT CALL + 2 WITH--
;R0	STILL HAS CHARACTER
;R1	HAS INDEX X2 OF FOUND CHARACTER IF C=0
;C=1	CHARACTER WAS NOT FOUND

LOOKUP:	MOV	(R5),R1		;GET LIST START
10$:	CMPB	R0,(R1)		;IS THIS THE ONE
	BNE	20$		;RIGHT IT WASN'T
	SUB	(R5)+,R1	;COMPUTE INDEX AND RETURN
	ASL	R1		;DO THIS FOR EVERBODY, C=0
	BR	30$
20$:	TSTB	(R1)+		;CHECK FOR END OF LIST
	BNE	10$		;IF NOT LOOK AT NEXT ITEM
	TST	(R5)+		;END, AVOID ILLEGAL INSTRUCTION
	SEC			;SECURITY EXCHANGE COMMISION
30$:	RTS	R5		;SECURITY ELSEWHERE
 
 
;GET CONTENTS OF ADDRESS IN THE MODE		JSR PC,GETCAD

;NEEDS--
;R0		THE MODE 1=BYTE, 2=WORD
;CAD		THE ADDRESS
;DEVI		THE DEVICE CODE

;RETURNS--
;R0		HAS THE DATA YOU ASKED FOR


	.IF DF	K$$DAS	
 
GETCAD:	MOV	SP,OPN		;SET LOCATION OPEN
	CALL	GETIT		;READ WORD OR BYTE FROM PROPER SPACE
	MOV	(SP)+,R0	;RETRIEVE WORD OR BYTE
GETC99:	RTS	PC		;

	.IFF
 
GETCAD:	MOV	CAD,R3		; GET CORE ADDRESS
	MOV	SP,OPN		; SET LOCATION OPEN
	ASR	R0		;PUSH BW FLAG INTO CARRY BIT
	BCC	10$		;2 WON'T FIT SO IS WORD
	MOVB	(R3),R0		;ACCESS BYTE
	BR	GETC99
10$:	MOV	(R3),R0		;ACCESS WORD
GETC99:	RTS	PC		;STACK ACCESS
 
	.IFTF

;PUT R4 INTO ADDRESS IN THE MODE		JSR PC,PUTCAD

;NEEDS--
;R2		CONTENT FLAG, 0 FOR NONE, ELSE R4 IS GOLD
;R4		THE DATA
;BW		THE MODE FLAG, IF 0 THEN NO LOCATION OPEN

	.IFT
 
PUTCAD:	MOV	BW,R0		;PICK UP MODE AN CC'S
	CALL	GETIT		;READ WORD OR BYTE FROM PROPER SPACE
	TST	R2		;CHECK FOR TYPED VALUE
	BEQ	12$		;NO DATA
	TST	OPN		;IS A LOCATION OPEN AT PRESENT?
	BEQ	12$		;NOT OPEN
	BIT	#177776,R0	;CHECK MODE
	BNE	5$		;WORD MODE
	MOVB	R4,(SP)		;WRITE THE DATA	
	BIT	#1,CAD		;HIGH BYTE?
	BEQ	10$		;IF EQ NO
	SWAB	(SP)		;MOVE IT BACK TO HIGH BYTE
	BR	10$		;
5$:	MOV	R4,(SP)		;STORE THE DATA	
10$:	MOV	(SP),-(SP)	;DUPLICATE DATA ON STACK
	TST	R1		;DATA SPACE?
	BNE	11$		;IF NE YES
	MTPI	(R3)		;WRITE WORD BACK TO I SPACE		
	BR	12$		;					
11$:	MTPD	(R3)		;WRITE WORD BACK TO D SPACE
12$:	MOV	(SP)+,R4	;RETURN DATA IN R4
	RTS	PC		;					 	


	.IFF
 
PUTCAD:	MOV	CAD,R3		;GET CORE ADDRESS
	TST	R2		;CHECK FOR TYPED VALUE	
	BEQ	12$		;NO DATA NO DODO			;**-1
	MOV	BW,R0		;PICK UP MODE AN CC'S
	TST	OPN		; IS A LOCATION OPEN AT PRESENT?
	BEQ	12$		;NOT OPEN NOT STORED
	BIT	#177776,R0	;CHECK MODE				;**-1
	BNE	10$		;WORD MODE
	MOVB	R4,(R3)		;BYTE MODE
	BR	12$		;BRANCH MODE
10$:	MOV	R4,(R3)		;WORD MODE
12$:	BIC	#1,R3		;INSURE EVEN ADDRESS	
	MOV	(R3),R4		;READ WORD FROM OPEN LOCATION	
	RTS	PC		;
									;**-1
	.IFTF


;GET WORD FROM PROPER SPACE
 
;NEEDS--
;R0		BW FLAG	
 
;RETURNS--
;R1		0 IF DATA FROM I SPACE, 1 IF FROM D SPACE
;R3		CURRENT ADDRESS FROM CAD WITH LOW BIT CLEAR
 
	.IFT
 
GETIT:	MOV	CAD,R3		;GET CURRENT ADDRESS
	BIC	#1,R3		;CLEAR LOW ORDER BIT
	MOV	(SP),-(SP)	;DUPLICATE RETURN ADDRESS
	CLR	R1		;ASSUME I SPACE	
	TSTB	REGFL		;REGISTER ACCESS?
	BNE	10$		;IF NE YES, USE D SPACE	
	CMPB	DMODE,#'D	;IN D SPACE MODE?
	BEQ	10$		;IF EQ YES
	MFPI	(R3)		;READ FROM I SPACE
	BR	20$		;
10$:	MFPD	(R3)		;READ FROM D SPACE
	INC	R1		;SET D SPACE FLAG
20$:	BIT	#1,CAD		;HIGH BYTE DESIRED?
	BEQ	30$		;IF EQ NO
	SWAB	(SP)		;REVERSE BYTES ON STACK
30$:	MOV	(SP)+,2(SP)	;PLACE WORD IN PROPER PLACE
	RETURN			;
 
 
;SET KERNEL I-SPACE DESCRIPTOR REGISTERS TO READ/WRITE
 
;NEEDS--
;R0
;CALLED ONLY FOR I/D SPACE SYSTEM
 
;RETURNS--
 
SETRW:	BIT	#1,SR0		;MAPPING ENABLED YET
	BEQ	20$		;NO
	BIT	#4,SR3		;KERNEL DATA SPACE ENABLED YET
	BEQ	20$		;NO
	MOV	#KINDR0,R0	;POINT TO KERNEL INSTR DESCR REG 0
10$:	BIS	#4,(R0)+	;SET RW ACCESS FOR XDT
	CMP	R0,#KINDR7	;DONE YET
	BLOS	10$		;NO
20$:	RETURN			;
 
 
	.ENDC
 
 
;SELECT RELOCATION REGISTER			JSR PC,LOCA

;CAD		ADDRESS TO USE IN SELECTION

;RETURNS--
;R0				REGISTER NUMBER FOUND, -1 IF NONE FOUND
;R1				DISTANCE, RELOCATION FACTOR

;SUBROUTINE TO LOCATE RELOCATION REGISTER NEAREST BUT STILL
;BELOW THE ADDRESS IN CAD.  RETURNS WITH THE REGISTER
;NUMBER IN R0, AND WITH THE DISTANCE BETWEEN THE REGISTER
;AND (CAD) IN R1
;IF NO GOOD RELOC. REG. FOUND, R0 WILL = -1

LOCA:	CLR	R0
	MOV	#-1,-(SP)	;INITIALIZE RELOC. REG. INDEX
	MOV	(SP),R1		;INITIALIZE DISTANCE TO A HIGH VALUE
10$:	CMP	R0,#RLR		;ARE WE DONE COMPARING?
	BHI	20$		;BRANCH IF DONE
	CMP	RELT(R0),R4	;IS CURR. RELOC. BIAS > (R4)?
	BHI	15$		;IF SO, BRANCH -- DON'T SUBTRACT, GET NEXT
	MOV	R4,R2		;OTHERWISE TAKE THE DIFFERENCE
	SUB	RELT(R0),R2	;OF CURR. RELOC. REG. AND CAD
	CMP	R1,R2		;IS THE RESULT THE SMALLEST SO FAR?
	BHI	25$		;BRANCH IF YES (UNSIGNED CONDITIONAL)
15$:	TST	(R0)+		;OTHERWISE, BUMP R0 FOR NEXT RELOC. REG.
	BR	10$		;LOOP BACK FOR NEXT COMPARISON
20$:	MOV	(SP)+,R0	;PUT REG.# IN R0
	RTS	PC		;JOB OVER, RETURN
25$:	MOV	R2,R1		;REMEMBER SMALLEST DIFFERENCE IN XXY
	ASR	R0		;AND ASSOCIATED REGISTER NUMBER
	MOV	R0,(SP)		; IN (SP)
	ASL	R0		;RESTORE R0 TO ORIGINAL VALUE
	BR	15$		;GO FO NEXT COMPARISON.

	.ENDC	;DF X$$DBT

	.IIF	DF  X$$DBT	.END	$XDT
	.IIF	NDF X$$DBT	.END